home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Tool Chest / Development Tools & Languages / Macintosh Common Lisp Related / interfaces / AOCE folder / OCE.lisp < prev    next >
Encoding:
Text File  |  1994-09-12  |  61.8 KB  |  1,624 lines  |  [TEXT/CCL2]
  1.  
  2. (in-package :TRAPS)             ; ***********************************************************
  3. ; 
  4. ; Created: Monday, November 8, 1993 11:28 AM
  5. ;  OCE.p
  6. ;  Pascal Interface to the Macintosh Libraries
  7. ; 
  8. ;   Copyright Apple Computer, Inc. 1990-1993
  9. ;   All rights reserved
  10. ; 
  11. ; ***********************************************************
  12.  
  13. ; $IFC UNDEFINED UsingIncludes
  14. ; $SETC UsingIncludes:= 0
  15. ; $ENDC
  16.  
  17. ; $IFC NOT UsingIncludes
  18.  
  19. ; $ENDC
  20.  
  21. ; $IFC UNDEFINED UsingOCE
  22. ; $SETC UsingOCE:= 1
  23.  
  24. ; $I+
  25. ; $SETC OCEIncludes:= UsingIncludes
  26. ; $SETC UsingIncludes:= 1
  27.  
  28. ; $IFC UNDEFINED UsingAliases
  29.  
  30. (require-interface 'ALIASES)    ; $I $$Shell(PInterfaces)Aliases.p;  for AliasPtr 
  31. ; $ENDC
  32.  
  33. ; $IFC UNDEFINED UsingAppleEvents
  34.  
  35. (require-interface 'APPLEEVENTS); $I $$Shell(PInterfaces)AppleEvents.p;  for DescType 
  36. ; $ENDC
  37.  
  38. ; $IFC UNDEFINED UsingScript
  39.  
  40. (require-interface 'SCRIPT)     ; $I $$Shell(PInterfaces)Script.p;  for smRoman 
  41. ; $ENDC
  42.  
  43. ; $IFC UNDEFINED UsingTypes
  44.  
  45. (require-interface 'TYPES)      ; $I $$Shell(PInterfaces)Types.p
  46. ; $ENDC
  47.  
  48. ; $SETC UsingIncludes:= OCEIncludes
  49.  
  50. ; 
  51. ; All utility routines defined here are callable at interrupt level.  Currently,
  52. ; this is done at the expense of not using the international utilities package
  53. ; for STRING comparisons (we just use the ROM-based RelString trap).
  54. ; 
  55.  
  56. ; 
  57. ; Defines for the trap selector values.
  58. ; 
  59. ; Note:  Some selector values also chosen from this same range of numbers appear
  60. ; in the file OCEMessaging.h.  Check there before you add a new value.
  61. ; 
  62.  
  63. (defconstant $kOCECopyCreationID 768)
  64. (defconstant $kOCECopyDirDiscriminator 769)
  65. (defconstant $kOCECopyLocalRecordID 770)
  66. (defconstant $kOCECopyPackedDSSpec 771)
  67. (defconstant $kOCECopyPackedPathName 772)
  68. (defconstant $kOCECopyPackedRLI 773)
  69. (defconstant $kOCECopyPackedRecordID 774)
  70. (defconstant $kOCECopyRLI 775)
  71. (defconstant $kOCECopyRString 776)
  72. (defconstant $kOCECopyRecordID 777)
  73. (defconstant $kOCECopyShortRecordID 778)
  74. (defconstant $kOCEDuplicateRLI 779)
  75. (defconstant $kOCEEqualCreationID 780)
  76. (defconstant $kOCEEqualDirDiscriminator 781)
  77. (defconstant $kOCEEqualDSSpec 782)
  78. (defconstant $kOCEEqualLocalRecordID 783)
  79. (defconstant $kOCEEqualPackedDSSpec 784)
  80. (defconstant $kOCEEqualPackedPathName 785)
  81. (defconstant $kOCEEqualPackedRecordID 786)
  82. (defconstant $kOCEEqualPackedRLI 787)
  83. (defconstant $kOCEEqualRecordID 788)
  84. (defconstant $kOCEEqualRLI 789)
  85. (defconstant $kOCEEqualRString 790)
  86. (defconstant $kOCEEqualShortRecordID 791)
  87. (defconstant $kOCEExtractAlias 792)
  88. (defconstant $kOCEGetDSSpecInfo 793)
  89. (defconstant $kOCEGetIndAttributeType 794)
  90. (defconstant $kOCEGetIndRecordType 795)
  91. (defconstant $kOCEGetXtnType 796)
  92. (defconstant $kOCEIsNullPackedPathName 797)
  93. (defconstant $kOCENewLocalRecordID 798)
  94. (defconstant $kOCENewRLI 799)
  95. (defconstant $kOCENewRecordID 800)
  96. (defconstant $kOCENewShortRecordID 801)
  97. (defconstant $kOCEPackDSSpec 802)
  98. (defconstant $kOCEPackPathName 803)
  99. (defconstant $kOCEPackRLI 804)
  100. (defconstant $kOCEPackRLIParts 805)
  101. (defconstant $kOCEPackRecordID 806)
  102. (defconstant $kOCEPackedDSSpecSize 807)
  103. (defconstant $kOCEPackedPathNameSize 808)
  104. (defconstant $kOCEPackedRLIPartsSize 809)
  105. (defconstant $kOCEPackedRLISize 810)
  106. (defconstant $kOCEPackedRecordIDSize 811)
  107. (defconstant $kOCEDNodeNameCount 812)
  108. (defconstant $kOCERelRString 813)
  109. (defconstant $kOCESetCreationIDtoNull 814)
  110. (defconstant $kOCEUnpackDSSpec 815)
  111. (defconstant $kOCEUnpackPathName 816)
  112. (defconstant $kOCEUnpackRLI 817)
  113. (defconstant $kOCEUnpackRecordID 818)
  114. (defconstant $kOCEValidPackedDSSpec 819)
  115. (defconstant $kOCEValidPackedPathName 820)
  116. (defconstant $kOCEValidPackedRecordID 821)
  117. (defconstant $kOCEValidPackedRLI 822)
  118. (defconstant $kOCEValidRLI 823)
  119. (defconstant $kOCEValidRString 824)
  120. (defconstant $kOCECToRString 825)
  121. (defconstant $kOCEPToRString 826)
  122. (defconstant $kOCERToPString 827)
  123. (defconstant $kOCEPathFinderCID 828)
  124. (defconstant $kOCEStreamPackedDSSpec 829)
  125.  
  126. (defconstant $kOCENullCID 836)
  127. (defconstant $kOCEGetAccessControlDSSpec 837)
  128. (defconstant $kOCEGetRootPackedRLI 838)
  129.  
  130. (def-mactype :OCERECORDTYPEINDEX (find-mactype :SIGNED-INTEGER))
  131. (def-mactype :OCEATTRIBUTETYPEINDEX (find-mactype :SIGNED-INTEGER))
  132.  
  133. ; 
  134. ; All these standard definitions begin with the Apple symbol (not shown here).
  135. ; 
  136. ; NOTE:  To access these, you must call OCEGetIndRecordType or OCEGetIndAttributeType
  137. ; with the proper index.  These routines return pointers to the standard type.
  138. ; This was done so that code fragments (INITs, CDEVs, DSAMs, etc). which cannot
  139. ; use global data can also use these.
  140. ; 
  141.  
  142. ;  Indices for the standard definitions for certain record types (OCERecordTypeIndex): 
  143.  
  144. (defconstant $kUserRecTypeNum 1);  "User" 
  145. (defconstant $kGroupRecTypeNum 2);  "Group" 
  146. (defconstant $kMnMRecTypeNum 3) ;  "AppleMail™ M&M" 
  147. (defconstant $kMnMForwarderRecTypeNum 4);  "AppleMail™ Fwdr" 
  148. (defconstant $kNetworkSpecRecTypeNum 5);  "NetworkSpec" 
  149. (defconstant $kADAPServerRecTypeNum 6);  "ADAP Server" 
  150. (defconstant $kADAPDNodeRecTypeNum 7);  "ADAP DNode" 
  151. (defconstant $kADAPDNodeRepRecTypeNum 8);  "ADAP DNode Rep" 
  152. (defconstant $kServerSetupRecTypeNum 9);  "Server Setup" 
  153. (defconstant $kDirectoryRecTypeNum 10);  "Directory" 
  154. (defconstant $kDNodeRecTypeNum 11);  "DNode" 
  155. (defconstant $kSetupRecTypeNum 12);  "Setup" 
  156. (defconstant $kMSAMRecTypeNum 13);  "MSAM" 
  157. (defconstant $kDSAMRecTypeNum 14);  "DSAM" 
  158. (defconstant $kAttributeValueRecTypeNum 15);  "Attribute Value" 
  159. (defconstant $kBusinessCardRecTypeNum 16);  "Business Card" 
  160. (defconstant $kMailServiceRecTypeNum 17);  "Mail Service" 
  161. (defconstant $kCombinedRecTypeNum 18);  "Combined" 
  162. (defconstant $kOtherServiceRecTypeNum 19);  "Other Service" 
  163. (defconstant $kAFPServiceRecTypeNum 20);  "Other Service afps" 
  164.  
  165. (defconstant $kFirstOCERecTypeNum #$KUSERRECTYPENUM);  first standard OCE record type 
  166. (defconstant $kLastOCERecTypeNum #$KAFPSERVICERECTYPENUM);  last standard OCE record type 
  167. (defconstant $kNumOCERecTypes (- #$KLASTOCERECTYPENUM (+ #$KFIRSTOCERECTYPENUM 1)))
  168.  
  169. ;  Indices for the standard definitions for certain attribute types (OCEAttributeTypeIndex): 
  170.  
  171. (defconstant $kMemberAttrTypeNum 1001);  "Member" 
  172. (defconstant $kAdminsAttrTypeNum 1002);  "Administrators" 
  173. (defconstant $kMailSlotsAttrTypeNum 1003);  "mailslots" 
  174. (defconstant $kPrefMailAttrTypeNum 1004);  "pref mailslot" 
  175. (defconstant $kAddressAttrTypeNum 1005);  "Address" 
  176. (defconstant $kPictureAttrTypeNum 1006);  "Picture" 
  177. (defconstant $kAuthKeyAttrTypeNum 1007);  "auth key" 
  178. (defconstant $kTelephoneAttrTypeNum 1008);  "Telephone" 
  179. (defconstant $kNBPNameAttrTypeNum 1009);  "NBP Name" 
  180. (defconstant $kQMappingAttrTypeNum 1010);  "ForwarderQMap" 
  181. (defconstant $kDialupSlotAttrTypeNum 1011);  "DialupSlotInfo" 
  182. (defconstant $kHomeNetAttrTypeNum 1012);  "Home Internet" 
  183. (defconstant $kCoResAttrTypeNum 1013);  "Co-resident M&M" 
  184. (defconstant $kFwdrLocalAttrTypeNum 1014);  "FwdrLocalRecord" 
  185. (defconstant $kConnectAttrTypeNum 1015);  "Connected To" 
  186. (defconstant $kForeignAttrTypeNum 1016);  "Foreign RLIs" 
  187. (defconstant $kOwnersAttrTypeNum 1017);  "Owners" 
  188. (defconstant $kReadListAttrTypeNum 1018);  "ReadList" 
  189. (defconstant $kWriteListAttrTypeNum 1019);  "WriteList" 
  190. (defconstant $kDescriptorAttrTypeNum 1020);  "Descriptor" 
  191. (defconstant $kCertificateAttrTypeNum 1021);  "Certificate" 
  192. (defconstant $kMsgQsAttrTypeNum 1022);  "MessageQs" 
  193. (defconstant $kPrefMsgQAttrTypeNum 1023);  "PrefMessageQ" 
  194. (defconstant $kMasterPFAttrTypeNum 1024);  "MasterPF" 
  195. (defconstant $kMasterNetSpecAttrTypeNum 1025);  "MasterNetSpec" 
  196. (defconstant $kServersOfAttrTypeNum 1026);  "Servers Of" 
  197. (defconstant $kParentCIDAttrTypeNum 1027);  "Parent CID" 
  198. (defconstant $kNetworkSpecAttrTypeNum 1028);  "NetworkSpec" 
  199. (defconstant $kLocationAttrTypeNum 1029);  "Location" 
  200. (defconstant $kTimeSvrTypeAttrTypeNum 1030);  "TimeServer Type" 
  201. (defconstant $kUpdateTimerAttrTypeNum 1031);  "Update Timer" 
  202. (defconstant $kShadowsOfAttrTypeNum 1032);  "Shadows Of" 
  203. (defconstant $kShadowServerAttrTypeNum 1033);  "Shadow Server" 
  204. (defconstant $kTBSetupAttrTypeNum 1034);  "TB Setup" 
  205. (defconstant $kMailSetupAttrTypeNum 1035);  "Mail Setup" 
  206. (defconstant $kSlotIDAttrTypeNum 1036);  "SlotID" 
  207. (defconstant $kGatewayFileIDAttrTypeNum 1037);  "Gateway FileID" 
  208. (defconstant $kMailServiceAttrTypeNum 1038);  "Mail Service" 
  209. (defconstant $kStdSlotInfoAttrTypeNum 1039);  "Std Slot Info" 
  210. (defconstant $kAssoDirectoryAttrTypeNum 1040);  "Asso. Directory" 
  211. (defconstant $kDirectoryAttrTypeNum 1041);  "Directory" 
  212. (defconstant $kDirectoriesAttrTypeNum 1042);  "Directories" 
  213. (defconstant $kSFlagsAttrTypeNum 1043);  "SFlags" 
  214. (defconstant $kLocalNameAttrTypeNum 1044);  "Local Name" 
  215. (defconstant $kLocalKeyAttrTypeNum 1045);  "Local Key" 
  216. (defconstant $kDirUserRIDAttrTypeNum 1046);  "Dir User RID" 
  217. (defconstant $kDirUserKeyAttrTypeNum 1047);  "Dir User Key" 
  218. (defconstant $kDirNativeNameAttrTypeNum 1048);  "Dir Native Name" 
  219. (defconstant $kCommentAttrTypeNum 1049);  "Comment" 
  220. (defconstant $kRealNameAttrTypeNum 1050);  "Real Name" 
  221. (defconstant $kPrivateDataAttrTypeNum 1051);  "Private Data" 
  222. (defconstant $kDirTypeAttrTypeNum 1052);  "Directory Type" 
  223. (defconstant $kDSAMFileAliasAttrTypeNum 1053);  "DSAM File Alias" 
  224. (defconstant $kCanAddressToAttrTypeNum 1054);  "Can Address To" 
  225. (defconstant $kDiscriminatorAttrTypeNum 1055);  "Discriminator" 
  226. (defconstant $kAliasAttrTypeNum 1056);  "Alias" 
  227. (defconstant $kParentMSAMAttrTypeNum 1057);  "Parent MSAM" 
  228. (defconstant $kParentDSAMAttrTypeNum 1058);  "Parent DSAM" 
  229. (defconstant $kSlotAttrTypeNum 1059);  "Slot" 
  230. (defconstant $kAssoMailServiceAttrTypeNum 1060);  "Asso. Mail Service" 
  231. (defconstant $kFakeAttrTypeNum 1061);  "Fake" 
  232. (defconstant $kInheritSysAdminAttrTypeNum 1062);  "Inherit SysAdministrators" 
  233. (defconstant $kPreferredPDAttrTypeNum 1063);  "Preferred PD" 
  234. (defconstant $kLastLoginAttrTypeNum 1064);  "Last Login" 
  235. (defconstant $kMailerAOMStateAttrTypeNum 1065);  "Mailer AOM State" 
  236. (defconstant $kMailerSendOptionsAttrTypeNum 1066);  "Mailer Send Options" 
  237. (defconstant $kJoinedAttrTypeNum 1067);  "Joined" 
  238. (defconstant $kUnconfiguredAttrTypeNum 1068);  "Unconfigured" 
  239. (defconstant $kVersionAttrTypeNum 1069);  "Version" 
  240. (defconstant $kLocationNamesAttrTypeNum 1070);  "Location Names" 
  241. (defconstant $kActiveAttrTypeNum 1071);  "Active" 
  242. (defconstant $kDeleteRequestedAttrTypeNum 1072);  "Delete Requested" 
  243. (defconstant $kGatewayTypeAttrTypeNum 1073);  "Gateway Type" 
  244.  
  245. (defconstant $kFirstOCEAttrTypeNum #$KMEMBERATTRTYPENUM);  first standard OCE attr type 
  246. (defconstant $kLastOCEAttrTypeNum #$KGATEWAYTYPEATTRTYPENUM);  last standard OCE attr type 
  247. (defconstant $kNumOCEAttrTypes (- #$KLASTOCEATTRTYPENUM (+ #$KFIRSTOCEATTRTYPENUM 1)))
  248.  
  249. ;  For anyone who absolutely needs a define of the body of the standard record or
  250. ; attribute type, use these below.  CAUTION!  All the types below are assumed to be
  251. ; in character set 'smRoman'.  If you try to compare these to some RString or
  252. ; AttributeType variable, you must take the character set code into account.  Future
  253. ; standard types may be defined using character sets other than 'smRoman'.  The
  254. ; first character of each of these is $F0, the Apple symbol.
  255. ; 
  256.  
  257. ;  Standard definitions for certain record types: 
  258.  
  259. (defconstant $kUserRecTypeBody "aoce User")
  260. (defconstant $kGroupRecTypeBody "aoce Group")
  261. (defconstant $kMnMRecTypeBody "aoce AppleMail™ M&M")
  262. (defconstant $kMnMForwarderRecTypeBody "aoce AppleMail™ Fwdr")
  263. (defconstant $kNetworkSpecRecTypeBody "aoce NetworkSpec")
  264. (defconstant $kADAPServerRecTypeBody "aoce ADAP Server")
  265. (defconstant $kADAPDNodeRecTypeBody "aoce ADAP DNode")
  266. (defconstant $kADAPDNodeRepRecTypeBody "aoce ADAP DNode Rep")
  267. (defconstant $kServerSetupRecTypeBody "aoce Server Setup")
  268. (defconstant $kDirectoryRecTypeBody "aoce Directory")
  269. (defconstant $kDNodeRecTypeBody "aoce DNode")
  270. (defconstant $kSetupRecTypeBody "aoce Setup")
  271. (defconstant $kMSAMRecTypeBody "aoce MSAM")
  272. (defconstant $kDSAMRecTypeBody "aoce DSAM")
  273. (defconstant $kAttributeValueRecTypeBody "aoce Attribute Value")
  274. (defconstant $kBusinessCardRecTypeBody "aoce Business Card")
  275. (defconstant $kMailServiceRecTypeBody "aoce Mail Service")
  276. (defconstant $kCombinedRecTypeBody "aoce Combined")
  277. (defconstant $kOtherServiceRecTypeBody "aoce Other Service")
  278. (defconstant $kAFPServiceRecTypeBody "aoce Other Service afps")
  279.  
  280. ;  Standard definitions for certain attribute types: 
  281.  
  282. (defconstant $kMemberAttrTypeBody "aoce Member")
  283. (defconstant $kAdminsAttrTypeBody "aoce Administrators")
  284. (defconstant $kMailSlotsAttrTypeBody "aoce mailslots")
  285. (defconstant $kPrefMailAttrTypeBody "aoce pref mailslot")
  286. (defconstant $kAddressAttrTypeBody "aoce Address")
  287. (defconstant $kPictureAttrTypeBody "aoce Picture")
  288. (defconstant $kAuthKeyAttrTypeBody "aoce auth key")
  289. (defconstant $kTelephoneAttrTypeBody "aoce Telephone")
  290. (defconstant $kNBPNameAttrTypeBody "aoce NBP Name")
  291. (defconstant $kQMappingAttrTypeBody "aoce ForwarderQMap")
  292. (defconstant $kDialupSlotAttrTypeBody "aoce DialupSlotInfo")
  293. (defconstant $kHomeNetAttrTypeBody "aoce Home Internet")
  294. (defconstant $kCoResAttrTypeBody "aoce Co-resident M&M")
  295. (defconstant $kFwdrLocalAttrTypeBody "aoce FwdrLocalRecord")
  296. (defconstant $kConnectAttrTypeBody "aoce Connected To")
  297. (defconstant $kForeignAttrTypeBody "aoce Foreign RLIs")
  298. (defconstant $kOwnersAttrTypeBody "aoce Owners")
  299. (defconstant $kReadListAttrTypeBody "aoce ReadList")
  300. (defconstant $kWriteListAttrTypeBody "aoce WriteList")
  301. (defconstant $kDescriptorAttrTypeBody "aoce Descriptor")
  302. (defconstant $kCertificateAttrTypeBody "aoce Certificate")
  303. (defconstant $kMsgQsAttrTypeBody "aoce MessageQs")
  304. (defconstant $kPrefMsgQAttrTypeBody "aoce PrefMessageQ")
  305. (defconstant $kMasterPFAttrTypeBody "aoce MasterPF")
  306. (defconstant $kMasterNetSpecAttrTypeBody "aoce MasterNetSpec")
  307. (defconstant $kServersOfAttrTypeBody "aoce Servers Of")
  308. (defconstant $kParentCIDAttrTypeBody "aoce Parent CID")
  309. (defconstant $kNetworkSpecAttrTypeBody "aoce NetworkSpec")
  310. (defconstant $kLocationAttrTypeBody "aoce Location")
  311. (defconstant $kTimeSvrTypeAttrTypeBody "aoce TimeServer Type")
  312. (defconstant $kUpdateTimerAttrTypeBody "aoce Update Timer")
  313. (defconstant $kShadowsOfAttrTypeBody "aoce Shadows Of")
  314. (defconstant $kShadowServerAttrTypeBody "aoce Shadow Server")
  315. (defconstant $kTBSetupAttrTypeBody "aoce TB Setup")
  316. (defconstant $kMailSetupAttrTypeBody "aoce Mail Setup")
  317. (defconstant $kSlotIDAttrTypeBody "aoce SlotID")
  318. (defconstant $kGatewayFileIDAttrTypeBody "aoce Gateway FileID")
  319. (defconstant $kMailServiceAttrTypeBody "aoce Mail Service")
  320. (defconstant $kStdSlotInfoAttrTypeBody "aoce Std Slot Info")
  321. (defconstant $kAssoDirectoryAttrTypeBody "aoce Asso. Directory")
  322. (defconstant $kDirectoryAttrTypeBody "aoce Directory")
  323. (defconstant $kDirectoriesAttrTypeBody "aoce Directories")
  324. (defconstant $kSFlagsAttrTypeBody "aoce SFlags")
  325. (defconstant $kLocalNameAttrTypeBody "aoce Local Name")
  326. (defconstant $kLocalKeyAttrTypeBody "aoce Local Key")
  327. (defconstant $kDirUserRIDAttrTypeBody "aoce Dir User RID")
  328. (defconstant $kDirUserKeyAttrTypeBody "aoce Dir User Key")
  329. (defconstant $kDirNativeNameAttrTypeBody "aoce Dir Native Name")
  330. (defconstant $kCommentAttrTypeBody "aoce Comment")
  331. (defconstant $kRealNameAttrTypeBody "aoce Real Name")
  332. (defconstant $kPrivateDataAttrTypeBody "aoce Private Data")
  333. (defconstant $kDirTypeAttrTypeBody "aoce Directory Type")
  334. (defconstant $kDSAMFileAliasAttrTypeBody "aoce DSAM File Alias")
  335. (defconstant $kCanAddressToAttrTypeBody "aoce Can Address To")
  336. (defconstant $kDiscriminatorAttrTypeBody "aoce Discriminator")
  337. (defconstant $kAliasAttrTypeBody "aoce Alias")
  338. (defconstant $kParentMSAMAttrTypeBody "aoce Parent MSAM")
  339. (defconstant $kParentDSAMAttrTypeBody "aoce Parent DSAM")
  340. (defconstant $kSlotAttrTypeBody "aoce Slot")
  341. (defconstant $kAssoMailServiceAttrTypeBody "aoce Asso. Mail Service")
  342. (defconstant $kFakeAttrTypeBody "aoce Fake")
  343. (defconstant $kInheritSysAdminAttrTypeBody "aoce Inherit SysAdministrators")
  344. (defconstant $kPreferredPDAttrTypeBody "aoce Preferred PD")
  345. (defconstant $kLastLoginAttrTypeBody "aoce Last Login")
  346. (defconstant $kMailerAOMStateAttrTypeBody "aoce Mailer AOM State")
  347. (defconstant $kMailerSendOptionsAttrTypeBody "aoce Mailer Send Options")
  348. (defconstant $kJoinedAttrTypeBody "aoce Joined")
  349. (defconstant $kUnconfiguredAttrTypeBody "aoce Unconfigured")
  350. (defconstant $kVersionAttrTypeBody "aoce Version")
  351. (defconstant $kLocationNamesAttrTypeBody "aoce Location Names")
  352. (defconstant $kActiveAttrTypeBody "aoce Active")
  353. (defconstant $kDeleteRequestedAttrTypeBody "aoce Delete Requested")
  354. (defconstant $kGatewayTypeAttrTypeBody "aoce Gateway Type")
  355.  
  356. ;  Miscellaneous enums: 
  357.  
  358. (defconstant $kRString32Size 32);  max size of the body field in RString32 
  359. (defconstant $kRString64Size 64);  max size of the body field in RString64 
  360. (defconstant $kNetworkSpecMaxBytes 32);  max size of the body field in NetworkSpec 
  361. (defconstant $kPathNameMaxBytes 1024);  max size of the data field in PackedPathName 
  362. (defconstant $kDirectoryNameMaxBytes 32);  max size of the body field in DirectoryName 
  363. (defconstant $kAttributeTypeMaxBytes 32);  max size of the body field in AttributeType 
  364. (defconstant $kAttrValueMaxBytes 65536);  max size of any attribute value 
  365. (defconstant $kRStringMaxBytes 256);  max size (bytes: in) of the body field of a recordName or recordType 
  366. (defconstant $kRStringMaxChars 128);  max size (chars: in) of the body field of a recordName or recordType 
  367.  
  368. (defconstant $kNULLDNodeNumber 0);  Special value meaning none specified 
  369. (defconstant $kRootDNodeNumber 2);  DNodeNum corresponding to the root of the tree 
  370.  
  371. ; 
  372. ; This enum is used to select the kind of RString in calls such as OCERelRString,
  373. ; OCEEqualRString, and OCEValidRString.
  374. ; 
  375. ; eGenericSensitive and eGenericInsensitive are enumerators that can be used if you
  376. ; use RStrings for things other than what you see in this file.  If you want them to
  377. ; be compared in a case- and diacritical-sensitive manner (c ≠ C ≠ ç), use
  378. ; eGenericSensitive.  If you want them to be compared in a case- and diacritical-
  379. ; insensitive manner (c = C = ç), use eGenericInensitive.
  380. ; WARNING:  do not use eGenericSensitive and eGenericInsensitive with directory
  381. ; names, entity names, pathname parts, entity types, network specs, or attribute
  382. ; types!  Don't assume that you know how they should be compared!!!
  383. ; 
  384.  
  385. ;  values of RStringKind 
  386.  
  387. (defconstant $kOCEDirName 0)
  388. (defconstant $kOCERecordOrDNodeName 1)
  389. (defconstant $kOCERecordType 2)
  390. (defconstant $kOCENetworkSpec 3)
  391. (defconstant $kOCEAttrType 4)
  392. (defconstant $kOCEGenericSensitive 5)
  393. (defconstant $kOCEGenericInsensitive 6)
  394.  
  395. (def-mactype :RSTRINGKIND (find-mactype :SIGNED-INTEGER))
  396.  
  397. ;  Values for the signature field in Discriminator 
  398.  
  399. ;  values of OCEDirectoryKind 
  400.  
  401. (defconstant $kDirAllKinds 0)
  402. (defconstant $kDirADAPKind :|adap|)
  403. (defconstant $kDirPersonalDirectoryKind :|pdir|)
  404. (defconstant $kDirDSAMKind :|dsam|)
  405.  
  406. (def-mactype :OCEDIRECTORYKIND (find-mactype :SIGNED-LONG))
  407.  
  408. ;  Values returned by GetDSSpecInfo() 
  409.  
  410. (defconstant $kOCEInvalidDSSpec :|????|);  could not be determined 
  411. (defconstant $kOCEDirsRootDSSpec :|root|);  root of all catalogs ("Catalogs" icon) 
  412. (defconstant $kOCEDirectoryDSSpec :|dire|);  catalog 
  413. (defconstant $kOCEDNodeDSSpec :|dnod|);  d-node 
  414. (defconstant $kOCERecordDSSpec :|reco|);  record 
  415. (defconstant $kOCEentnDSSpec :|entn|);  extensionType is 'entn' 
  416. (defconstant $kOCENOTentnDSSpec :|not |);  extensionType is not 'entn' 
  417.  
  418. ;  Values for AttributeTag 
  419. (defconstant $typeRString :|rstr|)
  420. (defconstant $typePackedDSSpec :|dspc|)
  421. (defconstant $typeBinary :|bnry|)
  422.  
  423. ; 
  424. ; Bit flag corresponding to the isCluster bit.  Use it like this:
  425. ;     if (foo & kCanContainRecordsBit)
  426. ;         then this is a cluster!
  427. ; kForeignNode is used to indicate nodes in the name hierarchy that correspond to
  428. ; foreign directories (meaning ADAP sees no clusters or DNodes beneath it, but
  429. ; mail routers might be able to route to clusters beneath it.
  430. ; 
  431.  
  432. (defconstant $kCanContainRecordsBit 0)
  433. (defconstant $kForeignNodeBit 1)
  434.  
  435. ;  values of DirNodeKind 
  436. (defconstant $kCanContainRecords #X1); 1<<kCanContainRecordsBit
  437. (defconstant $kForeignNode #X2) ; 1<<kForeignNodeBit
  438.  
  439. (def-mactype :DIRNODEKIND (find-mactype :SIGNED-LONG))
  440.  
  441. ; *** Toolbox Control ***
  442.  
  443. ; 
  444. ; We will have a version number and attributes for toolboxes off the aa5e trap
  445. ; and the S&F server trap.
  446. ; 
  447. ; This includes the OCE toolbox and S&F Server.  [Note: the S&F server will
  448. ; change to ONLY service ServerGateway calls —it will then be necessary to run
  449. ; it co–resident with an OCE toolbox].
  450. ; 
  451. ; The high order word will represent the S&F Server version number.  The low
  452. ; order word will represent the OCE toolbox version number.  These will be zero
  453. ; until the component is up and running.  It is not possible to know these
  454. ; a–priori. Note: there will not be a seperate version numbers for each component
  455. ; in the OCE toolbox or S&F server.
  456. ; 
  457. ; The above is consistent with the standard System 7.0 usage of Gestalt.
  458. ; 
  459. ; The oce tb attribute gestaltOCETBPresent implies the existence of OCE on a
  460. ; machine.
  461. ; 
  462. ; The OCE TB attribute gestaltOCETBAvailable implies the availablity of OCE calls.
  463. ; 
  464. ; The attribute gestaltOCESFServerAvailable implies the availablity of OCE calls
  465. ; available through the S&F server. This are essentially the server gateway calls.
  466. ; 
  467. ; Any (future) remaining OCE attributes may not be established correctly until
  468. ; the attribute gestaltOCETBAvailable is set.
  469. ; 
  470. ; The gestalt selectors and values are listed below:
  471. ; 
  472.  
  473. (defconstant $gestaltOCEToolboxVersion :|ocet|);  OCE Toolbox version 
  474. (defconstant $gestaltOCEToolboxAttr :|oceu|);  OCE Toolbox attributes 
  475.  
  476. ;  version includes:
  477. ;  *  dirtb
  478. ;  *  authtb
  479. ;  *  mailtb
  480. ;  *  ipmtb
  481. ;  *  personal directory
  482. ;  *  ADSPSecure
  483. ;  * e.g. all interfaces dependent on the aa5e trap.
  484. ; 
  485. (defconstant $gestaltOCETB #X100);  OCE Toolbox version 1.0 
  486. (defconstant $gestaltSFServer #X100);  S&F Server version 1.0 
  487. (defconstant $gestaltOCETBPresent #X1);  OCE toolbox is present, not running 
  488. (defconstant $gestaltOCETBAvailable #X2);  OCE toolbox is running and available 
  489. (defconstant $gestaltOCESFServerAvailable #X4);  S&F Server is running and available 
  490.  
  491. ;     Constants used for Transitions. 
  492.  
  493. (defconstant $ATTransIPMStart :|ipms|)
  494. (defconstant $ATTransIPMShutdown :|ipmd|)
  495. (defconstant $ATTransDirStart :|dirs|)
  496. (defconstant $ATTransDirShutdown :|dird|)
  497. (defconstant $ATTransAuthStart :|auts|)
  498. (defconstant $ATTransAuthShutdown :|autd|)
  499. (defconstant $ATTransSFStart :|s&fs|)
  500. (defconstant $ATTransSFShutdown :|s&fd|)
  501.  
  502. ;  Some definitions for time-related parameters: 
  503.  
  504. (def-mactype :UTCTIME (find-mactype :SIGNED-LONG));  Interpreted as UTC seconds since 1/1/1904 
  505. (def-mactype :UTCOFFSET (find-mactype :SIGNED-LONG));  seconds EAST of Greenwich 
  506.  
  507. (def-mactype :CHARACTERSET (find-mactype :SIGNED-INTEGER));  This is the same as the ScriptManager script. 
  508.  
  509. ; *** RString ***
  510.  
  511. ; 
  512. ; struct RString is a maximum-sized structure.  Allocate one of these and it will
  513. ; hold any valid RString.
  514. ; 
  515.  
  516. (defrecord RStringHeader 
  517.   (charSet :SIGNED-INTEGER)
  518.   (dataLength :SIGNED-INTEGER)
  519.   )
  520.  
  521. (defrecord RString 
  522.   (charSet :SIGNED-INTEGER)
  523.   (dataLength :SIGNED-INTEGER)
  524.   
  525.   (body (:ARRAY :UNSIGNED-BYTE 256));  place for characters { (:ARRAY :UNSIGNED-BYTE (- #$KRSTRINGMAXBYTES 1 -1)) }
  526.   )
  527.  
  528. ;  struct ProtoRString is a minimum-sized structure.  Use this for a variable-length
  529. ; RString. 
  530.  
  531. (defrecord ProtoRString         ;  proto-RString used for variable length rStrings 
  532.   (charSet :SIGNED-INTEGER)
  533.   (dataLength :SIGNED-INTEGER)
  534.   
  535.   ;  Followed by body 
  536.   )
  537.  
  538. (def-mactype :RSTRINGPTR (find-mactype :POINTER))
  539. (def-mactype :RSTRINGHANDLE (find-mactype :HANDLE))
  540. (def-mactype :PROTORSTRINGPTR (find-mactype :POINTER))
  541.  
  542. (defconstant $kMinPackedRStringLength (RECORD-LENGTH PROTORSTRING))
  543.  
  544. (defrecord RString64 
  545.   (charSet :SIGNED-INTEGER)
  546.   (dataLength :SIGNED-INTEGER)
  547.   
  548.   (body (:ARRAY :UNSIGNED-BYTE 64))        ; { (:ARRAY :UNSIGNED-BYTE (- #$KRSTRING64SIZE 1 -1)) }
  549.   )
  550.  
  551. (defrecord RString32 
  552.   (charSet :SIGNED-INTEGER)
  553.   (dataLength :SIGNED-INTEGER)
  554.   
  555.   (body (:ARRAY :UNSIGNED-BYTE 32))       ;  { (:ARRAY :UNSIGNED-BYTE (- #$KRSTRING32SIZE 1 -1)) }
  556.   )
  557.  
  558. (def-mactype :RSTRING32PTR (find-mactype :POINTER))
  559.  
  560. ; 
  561. ; Standard definitions for the entity type field and attribute type
  562. ; have been moved to the end of the file.
  563. ; 
  564.  
  565. ; 
  566. ; Copies str1 to str2.  str2Length is the size of str2, excluding header.
  567. ; A memFull error will be returned if that is not as large as str1->length.
  568. ; 
  569.  
  570.  
  571. (deftrap _ocecopyrstring ((str1 (:pointer :rstring)) (str2 (:pointer :rstring)) (str2length :signed-integer))
  572.          (:stack :signed-integer)
  573.   (:stack-trap #xAA5C :d0 776 str1 str2 str2length))
  574.  
  575. ;     Make an RString from a C STRING.  If the c STRING is bigger than rStrLength,
  576. ; only rStrLength bytes will be copied. (rStrLength does not include the header size) 
  577.  
  578.  
  579. (deftrap _ocectorstring ((cstr :pointer) (charset :signed-integer) (rstr (:pointer :rstring)) (rstrlength :signed-integer))
  580.          nil
  581.   (:stack-trap #xAA5C :d0 825 cstr charset rstr rstrlength))
  582.  
  583. ;     Make an RString from a Pascal STRING.  If the Pascal STRING is bigger than rStrLength,
  584. ; only rStrLength bytes will be copied. (rStrLength does not include the header size) 
  585.  
  586.  
  587. (deftrap _oceptorstring ((pstr (:string 255)) (charset :signed-integer) (rstr (:pointer :rstring)) (rstrlength :signed-integer))
  588.          nil
  589.   (:stack-trap #xAA5C :d0 826 pstr charset rstr rstrlength))
  590.  
  591. ;     Make a Pascal STRING from an RString.  It's up to you to check the CHAR set of
  592. ; the RString, or if the length of the RString is greater than 255 (the Pascal STRING's
  593. ; length will simply be the lower byte of the RString's length).  The StringPtr that is
  594. ; returned will point directly into the RString (no memory will be allocated). 
  595.  
  596.  
  597. (deftrap _ocertopstring ((rstr (:pointer :rstring)))
  598.          (:stack (:pointer (:string 255)))
  599.   (:stack-trap #xAA5C :d0 827 rstr))
  600.  
  601. ;     Check the relative equality of two RStrings.  Determines if str1 is greater than,
  602. ; equal to, or less than str2.  Result types for OCERelRString are defined in <OSUtils.h>
  603. ; (same as for RelString). 
  604.  
  605.  
  606. (deftrap _ocerelrstring ((str1 :pointer) (str2 :pointer) (kind :signed-integer))
  607.          (:stack :signed-integer)
  608.   (:stack-trap #xAA5C :d0 813 str1 str2 kind))
  609.  
  610. ;     Check for equality of two RStrings. Returns true if equal. 
  611.  
  612.  
  613. (deftrap _oceequalrstring ((str1 :pointer) (str2 :pointer) (kind :signed-integer))
  614.          (:stack :boolean)
  615.   (:stack-trap #xAA5C :d0 790 str1 str2 kind))
  616.  
  617. ;     Check the validity of an RString.  Returns true if the RString is valid 
  618.  
  619.  
  620. (deftrap _ocevalidrstring ((str :pointer) (kind :signed-integer))
  621.          (:stack :boolean)
  622.   (:stack-trap #xAA5C :d0 824 str kind))
  623.  
  624. ; *** CreationID ***
  625.  
  626. (defrecord CreationID 
  627.   (source :SIGNED-LONG)        ;  Fields definitions and usage are not defined 
  628.   (seq :SIGNED-LONG)
  629.   )
  630.  
  631. (%define-record :ATTRIBUTECREATIONID (find-record-descriptor :CREATIONID))
  632. (def-mactype :CREATIONIDPTR (find-mactype :POINTER))
  633.  
  634. ;  Returns a pointer to a null CreationID . 
  635.  
  636.  
  637. (deftrap _ocenullcid nil
  638.          (:stack (:pointer :creationid))
  639.   (:stack-trap #xAA5C :d0 836))
  640.  
  641. ;  Returns a pointer to a special CreationID used within the PathFinder. 
  642.  
  643.  
  644. (deftrap _ocepathfindercid nil
  645.          (:stack (:pointer :creationid))
  646.   (:stack-trap #xAA5C :d0 828))
  647.  
  648. ;  Sets the CreationID to a null value. 
  649.  
  650.  
  651. (deftrap _ocesetcreationidtonull ((cid (:pointer :creationid)))
  652.          nil
  653.   (:stack-trap #xAA5C :d0 814 cid))
  654.  
  655. ;  Copies the value of cid1 to cid2. 
  656.  
  657.  
  658. (deftrap _ocecopycreationid ((cid1 :creationid) (cid2 (:pointer :creationid)))
  659.          nil
  660.   (:stack-trap #xAA5C :d0 768 cid1 cid2))
  661.  
  662. ;  Check the equality of two CreationIDs. 
  663.  
  664.  
  665. (deftrap _oceequalcreationid ((cid1 :creationid) (cid2 :creationid))
  666.          (:stack :boolean)
  667.   (:stack-trap #xAA5C :d0 780 cid1 cid2))
  668.  
  669. ; *** NetworkSpec ***
  670.  
  671. ; 
  672. ; For the record, a NetworkSpec is an RString with a smaller maximum size.
  673. ; I don't justtypedef it to an RString, because I want the definition of the NetworkSpec
  674. ; struct to contain the max length.  But it should be possible to typecast any
  675. ; NetworkSpec to an RString and use all the RString utilities on it.
  676. ; 
  677.  
  678. (defrecord NetworkSpec 
  679.   (charSet :SIGNED-INTEGER)
  680.   (dataLength :SIGNED-INTEGER)
  681.   
  682.   (body (:ARRAY :UNSIGNED-BYTE 32));  always fixed at the max size { (:ARRAY :UNSIGNED-BYTE (- #$KNETWORKSPECMAXBYTES 1 -1)) }
  683.   )
  684.  
  685. (def-mactype :NETWORKSPECPTR (find-mactype :POINTER))
  686.  
  687. ; *** PackedPathName ***
  688.  
  689. ; 
  690. ; struct PackedPathName is a maximum-sized structure.  Allocate one of
  691. ; these and it will hold any valid packed pathname.
  692. ; 
  693.  
  694. (defrecord PackedPathNameHeader 
  695.   (dataLength :SIGNED-INTEGER) ;  length excludes the space for the length field 
  696.   )
  697.  
  698. (defconstant $kPathNameMaxBytesMinusSizeofInteger 1022)
  699.  
  700. (defrecord PackedPathName 
  701.   (dataLength :SIGNED-INTEGER)
  702.   
  703.   (data (:ARRAY :UNSIGNED-BYTE 1022))          ;  { (:ARRAY :UNSIGNED-BYTE (- #$KPATHNAMEMAXBYTESMINUSSIZEOFINTEGER 1 -1)) }
  704.   )
  705.  
  706. ; 
  707. ; struct ProtoPackedPathName is a minimum-sized structure.  Use this
  708. ; for a variable-length packed PathName.
  709. ; 
  710.  
  711. (defrecord ProtoPackedPathName 
  712.    (dataLength :SIGNED-INTEGER)
  713.  
  714. ;  Followed by data 
  715.    )
  716.  
  717. (def-mactype :PACKEDPATHNAMEPTR (find-mactype :POINTER))
  718. (def-mactype :PROTOPACKEDPATHNAMEPTR (find-mactype :POINTER))
  719.  
  720. ; 
  721. ; Copy the contents of path1 to path2.  path2Length is the size of path2, and must
  722. ; be large enough to hold a copy of path1.  A memFull error will be returned if that
  723. ; is not the case.
  724. ; 
  725.  
  726.  
  727. (deftrap _ocecopypackedpathname ((path1 (:pointer :packedpathname)) (path2 (:pointer :packedpathname)) (path2length :signed-integer))
  728.    (:stack :signed-integer)
  729.    (:stack-trap #xAA5C :d0 772 path1 path2 path2length))
  730.  
  731. ; 
  732. ; Returns true if packed path pointer is nil, or is of zero length, or is of
  733. ; length 2 and nParts of zero.
  734. ; 
  735.  
  736.  
  737. (deftrap _oceisnullpackedpathname ((path (:pointer :packedpathname)))
  738.    (:stack :boolean)
  739.    (:stack-trap #xAA5C :d0 797 path))
  740.  
  741. ; 
  742. ; OCEUnpackPathName breaks apart the path into its component RStrings, writing STRING
  743. ; pointers into the array 'parts', which the client asserts can hold as many as
  744. ; 'nParts' elements. The number of parts actually found is returned.  STRINGs are
  745. ; placed in the array in order from lowest to highest.  The first pathName element
  746. ; beneath the root appears last.  NOTE THAT THE UNPACKED STRUCT CONTAINS POINTERS INTO
  747. ; THE PACKED STRUCT - DON'T DELETE OR REUSE THE PACKED STRUCT UNTIL YOU ARE FINISHED
  748. ; WITH THE UNPACKED STRUCT AS WELL
  749. ; 
  750.  
  751.  
  752. (deftrap _oceunpackpathname ((path (:pointer :packedpathname)) (parts (:pointer (:pointer :rstring))) (nparts :signed-integer))
  753.    (:stack :signed-integer)
  754.    (:stack-trap #xAA5C :d0 816 path parts nparts))
  755.  
  756. ; 
  757. ; OCEPackedPathNameSize computes the number of bytes of memory needed to hold a
  758. ; PackedPathName manufactured from the array of parts.  This length
  759. ; includes the length of the length field of PackedPathName, so it
  760. ; is safe to do a NewPtr (OCEPackedPathNameSize(...)).
  761. ; 
  762.  
  763.  
  764. (deftrap _ocepackedpathnamesize ((parts (:pointer (:pointer :rstring))) (nparts :signed-integer))
  765.    (:stack :signed-integer)
  766.    (:stack-trap #xAA5C :d0 808 parts nparts))
  767.  
  768. ;  OCEDNodeNameCount returns the number of RStrings contained within the path. 
  769.  
  770.  
  771. (deftrap _ocednodenamecount ((path (:pointer :packedpathname)))
  772.    (:stack :signed-integer)
  773.    (:stack-trap #xAA5C :d0 812 path))
  774.  
  775. ; 
  776. ; OCEPackPathName packs the parts into the storage provided as 'path'.  path must be
  777. ; large enough to hold the packed pathname.  A memFull error will be returned if
  778. ; pathLength is too small.  parts[0] should contain the deepest pathName element,
  779. ; and parts[nParts - 1] should contain the name of the first pathName element beneath
  780. ; the root.
  781. ; 
  782.  
  783.  
  784. (deftrap _ocepackpathname ((parts (:pointer (:pointer :rstring))) (nparts :signed-integer) (path (:pointer :packedpathname)) (pathlength :signed-integer))
  785.    (:stack :signed-integer)
  786.    (:stack-trap #xAA5C :d0 803 parts nparts path pathlength))
  787.  
  788. ; 
  789. ; Check the equality of two packed paths.
  790. ; 
  791.  
  792.  
  793. (deftrap _oceequalpackedpathname ((path1 (:pointer :packedpathname)) (path2 (:pointer :packedpathname)))
  794.    (:stack :boolean)
  795.    (:stack-trap #xAA5C :d0 785 path1 path2))
  796.  
  797. ; 
  798. ; OCEValidPackedPathName checks that the packed PathName is internally consistent.
  799. ; Returns true if it's ok.
  800. ; 
  801.  
  802.  
  803. (deftrap _ocevalidpackedpathname ((path (:pointer :packedpathname)))
  804.    (:stack :boolean)
  805.    (:stack-trap #xAA5C :d0 820 path))
  806.  
  807. ; *** DirDiscriminator ***
  808.  
  809. (defrecord DirDiscriminator 
  810.    (signature :SIGNED-LONG)
  811.    (misc :SIGNED-LONG)
  812.    )
  813.  
  814. ;  Copies the value of disc1 to disc2. 
  815.  
  816.  
  817. (deftrap _ocecopydirdiscriminator ((disc1 :dirdiscriminator) (disc2 (:pointer :dirdiscriminator)))
  818.    nil
  819.    (:stack-trap #xAA5C :d0 769 disc1 disc2))
  820.  
  821. ;  Check the equality of two DirDiscriminators. 
  822.  
  823.  
  824. (deftrap _oceequaldirdiscriminator ((disc1 :dirdiscriminator) (disc2 :dirdiscriminator))
  825.    (:stack :boolean)
  826.    (:stack-trap #xAA5C :d0 781 disc1 disc2))
  827.  
  828. ; ********************************************************************************
  829. ; 
  830. ; This structure is called RLI because it really contains all the info you
  831. ; need to locate a record within the entire name space.  It contains four fields.
  832. ; The first two are the name of the directory and a directory discriminator.  These
  833. ; two fields are used to indicate to which directory a given record belongs.  The
  834. ; discriminator is used to distinguish between two different directories that have
  835. ; the same name.
  836. ; 
  837. ; The other two fields in the RLI structure are used to indicate a particular
  838. ; directory node within the directory specified by the directoryName and
  839. ; discriminator fields.  These fields are exactly analagous to the dirID and
  840. ; pathname used in HFS.  It is possible to specify a dNode just by dNodeNumber
  841. ; (pathname is nil), or just by pathname (dNodeNumber is set to kNULLDNodeNumber),
  842. ; or by a combination of the two.  The latter is called a 'partial pathname', and
  843. ; while it is valid in the Directory Manager API, it is not supported by ADAP
  844. ; directories in Release 1.
  845. ; 
  846. ; Note that the path parameter does not include the directory name, but holds
  847. ; the names of all the nodes on the path to the desired directory node, starting
  848. ; with the directory node and working its way up the tree.
  849. ; 
  850. ;  ********************************************************************************
  851.  
  852. ; *** RLI ***
  853.  
  854. (defrecord DirectoryName 
  855.    (charSet :SIGNED-INTEGER)
  856.    (dataLength :SIGNED-INTEGER)
  857.  
  858.    (body (:ARRAY :UNSIGNED-BYTE 32));  space for directory name  { (:ARRAY :UNSIGNED-BYTE (- #$KDIRECTORYNAMEMAXBYTES 1 -1)) }
  859.    )
  860.  
  861. (def-mactype :DIRECTORYNAMEPTR (find-mactype :POINTER))
  862.  
  863. (def-mactype :DNODENUM (find-mactype :SIGNED-LONG));  Directory node number 
  864.  
  865. (defrecord RLI                  ;  Record Location Info structure: 
  866.    (directoryName (:POINTER :DIRECTORYNAME));  pointer to the name of the directory root 
  867.    (discriminator :DIRDISCRIMINATOR);  used to discriminate between dup dir names 
  868.    (dNodeNumber :SIGNED-LONG)   ;  number of the node 
  869.    (path (:POINTER :PACKEDPATHNAME));  old-style RLI 
  870.    )
  871.  
  872. (def-mactype :RLIPTR (find-mactype :POINTER))
  873.  
  874. ; 
  875. ; Create a new RLI from the directory name, discriminator, DNode number, and
  876. ; PackedPathName.  You must allocate the storage for the RLI and pass in a pointer
  877. ; to it.
  878. ; 
  879.  
  880.  
  881. (deftrap _ocenewrli ((newrli (:pointer :rli)) (dirname (:pointer :directoryname)) (discriminator (:pointer :dirdiscriminator)) (dnodenumber :signed-long) (path (:pointer :packedpathname)))
  882.    nil
  883.    (:stack-trap #xAA5C :d0 799 newrli dirname discriminator dnodenumber path))
  884.  
  885. ; 
  886. ; Duplicate the contents of rli1 to rli2.  No errors are returned. This
  887. ; simply copies the pointers to the directory name and path, wiping out any pointer
  888. ; that you might have had in there.
  889. ; 
  890.  
  891.  
  892. (deftrap _oceduplicaterli ((rli1 :rli) (rli2 (:pointer :rli)))
  893.    nil
  894.    (:stack-trap #xAA5C :d0 779 rli1 rli2))
  895.  
  896. ; 
  897. ; Copy the contents of rli1 to rli2.  rli2 must already contain
  898. ; pointers to structures large enough to hold copies of the corresponding
  899. ; fields from rli1.  A memFull error will be returned if that is not the case.
  900. ; So if you allocate a brand new empty destination, you must at least set up
  901. ; its length fields.
  902. ; 
  903.  
  904.  
  905. (deftrap _ocecopyrli ((rli1 :rli) (rli2 (:pointer :rli)))
  906.    (:stack :signed-integer)
  907.    (:stack-trap #xAA5C :d0 775 rli1 rli2))
  908.  
  909. ; 
  910. ; Check the equality of two RLIs.  This will take into account differences
  911. ; in the case and diacriticals of the directoryName and the PathName.
  912. ; NOTE THAT THIS WILL FAIL IF rli1 CONTAINS A DNODENUMBER AND A NIL PATHNAME,
  913. ; AND rli2 CONTAINS kNULLDNodeNumber AND A NON-NIL PATHNAME.  IN OTHER WORDS,
  914. ; THE TWO rlis MUST BE OF THE SAME FORM TO CHECK FOR EQUALITY.
  915. ; The one exception is that if the pathname is nil, a dNodeNumber of zero and
  916. ; kRootDNodeNumber will be treated as equal.
  917. ; 
  918.  
  919.  
  920. (deftrap _oceequalrli ((rli1 :rli) (rli2 :rli))
  921.    (:stack :boolean)
  922.    (:stack-trap #xAA5C :d0 789 rli1 rli2))
  923.  
  924. ; 
  925. ; Check the validity of an RLI.  This checks that the directory name length
  926. ; is within bounds, and the packed pathname (specified: if) is valid.
  927. ; 
  928.  
  929.  
  930. (deftrap _ocevalidrli ((therli :rli))
  931.    (:stack :boolean)
  932.    (:stack-trap #xAA5C :d0 823 therli))
  933.  
  934. ; *** PackedRLI ***
  935.  
  936. ; 
  937. ; struct PackedRLI is a maximum-sized structure.  Allocate one of
  938. ; these and it will hold any valid packed pathname.
  939. ; 
  940.  
  941. (defconstant $kRLIMaxBytes 1296)
  942.  
  943. (defrecord PackedRLIHeader 
  944.    (dataLength :SIGNED-INTEGER) ;  length excludes the space for the length field 
  945.    )
  946.  
  947. (defrecord PackedRLI 
  948.    (dataLength :SIGNED-INTEGER)
  949.  
  950.    (data (:ARRAY :UNSIGNED-BYTE 1296))         ;  { (:ARRAY :UNSIGNED-BYTE (- #$KRLIMAXBYTES 1 -1)) }
  951.    )
  952.  
  953. ; 
  954. ; struct ProtoPackedRLI is a minimum-sized structure.  Use this
  955. ; for a variable-length packed RLI.
  956. ; 
  957.  
  958. (defrecord ProtoPackedRLI 
  959.    (dataLength :SIGNED-INTEGER)
  960.  
  961. ;  Followed by data 
  962.    )
  963.  
  964. (def-mactype :PACKEDRLIPTR (find-mactype :POINTER))
  965. (def-mactype :PROTOPACKEDRLIPTR (find-mactype :POINTER))
  966.  
  967. (defconstant $kMinPackedRLISize (+ (RECORD-LENGTH PROTOPACKEDRLI) (+ (RECORD-LENGTH DIRDISCRIMINATOR) (+ (RECORD-LENGTH DNODENUM) (+ #$KMINPACKEDRSTRINGLENGTH (RECORD-LENGTH PROTOPACKEDPATHNAME))))))
  968.  
  969. ; 
  970. ; Copy the contents of prli1 to prli2.  prli2Length is the size of prli2, and must
  971. ; be large enough to hold a copy of prli1.  A memFull error will be returned if that
  972. ; is not the case.
  973. ; 
  974.  
  975.  
  976. (deftrap _ocecopypackedrli ((prli1 (:pointer :packedrli)) (prli2 (:pointer :packedrli)) (prli2length :signed-integer))
  977.    (:stack :signed-integer)
  978.    (:stack-trap #xAA5C :d0 773 prli1 prli2 prli2length))
  979.  
  980. ; 
  981. ; OCEUnpackRLI breaks apart the prli into its components, writing pointers into
  982. ; the rli structure.  NOTE THAT THE UNPACKED STRUCT CONTAINS POINTERS INTO THE
  983. ; PACKED STRUCT - DON'T DELETE OR REUSE THE PACKED STRUCT UNTIL YOU ARE FINISHED
  984. ; WITH THE UNPACKED STRUCT AS WELL
  985. ; 
  986.  
  987.  
  988. (deftrap _oceunpackrli ((prli (:pointer :packedrli)) (therli (:pointer :rli)))
  989.    nil
  990.    (:stack-trap #xAA5C :d0 817 prli therli))
  991.  
  992. ; 
  993. ; OCEPackedRLISize computes the number of bytes of memory needed to hold a
  994. ; PackedRLI manufactured from an RLI.  This length
  995. ; includes the length of the length field of PackedRLI, so it
  996. ; is safe to do a NewPtr (OCEPackedRLISize(...)).
  997. ; 
  998.  
  999.  
  1000. (deftrap _ocepackedrlisize ((therli :rli))
  1001.    (:stack :signed-integer)
  1002.    (:stack-trap #xAA5C :d0 810 therli))
  1003.  
  1004. ; 
  1005. ; OCEPackRLI packs the RLI into the storage provided as 'prli'.  prli must be
  1006. ; large enough to hold the packed RLI.  A memFull error will be returned if
  1007. ; prliLength is too small.
  1008. ; 
  1009.  
  1010.  
  1011. (deftrap _ocepackrli ((therli :rli) (prli (:pointer :packedrli)) (prlilength :signed-integer))
  1012.    (:stack :signed-integer)
  1013.    (:stack-trap #xAA5C :d0 804 therli prli prlilength))
  1014.  
  1015. ; 
  1016. ; OCEPackedRLIPartsSize computes the number of bytes of memory needed to hold a
  1017. ; PackedRLI manufactured from the parts of an RLI.  This length
  1018. ; includes the length of the length field of PackedRLI, so it
  1019. ; is safe to do a NewPtr (OCEPackedRLIPartsSize(...)).
  1020. ; 
  1021.  
  1022.  
  1023. (deftrap _ocepackedrlipartssize ((dirname (:pointer :directoryname)) (parts (:pointer (:pointer :rstring))) (nparts :signed-integer))
  1024.    (:stack :signed-integer)
  1025.    (:stack-trap #xAA5C :d0 809 dirname parts nparts))
  1026.  
  1027. ; 
  1028. ; OCEPackRLIParts packs the parts of an RLI into the storage provided as 'prli'.
  1029. ; prli must be large enough to hold the packed RLI.  A memFull error will be returned
  1030. ; if prliLength is too small.
  1031. ; 
  1032.  
  1033.  
  1034. (deftrap _ocepackrliparts ((dirname (:pointer :directoryname)) (discriminator :dirdiscriminator) (dnodenumber :signed-long) (parts (:pointer (:pointer :rstring))) (nparts :signed-integer) (prli (:pointer :packedrli)) (prlilength :signed-integer))
  1035.    (:stack :signed-integer)
  1036.    (:stack-trap #xAA5C :d0 805 dirname discriminator dnodenumber parts nparts prli prlilength))
  1037.  
  1038. ; 
  1039. ; Check the equality of two packed prlis.
  1040. ; 
  1041.  
  1042.  
  1043. (deftrap _oceequalpackedrli ((prli1 (:pointer :packedrli)) (prli2 (:pointer :packedrli)))
  1044.    (:stack :boolean)
  1045.    (:stack-trap #xAA5C :d0 787 prli1 prli2))
  1046.  
  1047. ; 
  1048. ; Check the validity of a packed RLI.  This checks that the directory name length
  1049. ; is within bounds, and the packed pathname (specified: if) is valid.
  1050. ; 
  1051.  
  1052.  
  1053. (deftrap _ocevalidpackedrli ((prli (:pointer :packedrli)))
  1054.    (:stack :boolean)
  1055.    (:stack-trap #xAA5C :d0 822 prli))
  1056.  
  1057. ; 
  1058. ; If this packed RLI describes a Personal Directory, this call will return a pointer
  1059. ; to an alias record that can be used to find the actual file.  Otherwise, it returns nil.
  1060. ; 
  1061.  
  1062.  
  1063. (deftrap _oceextractalias ((prli (:pointer :packedrli)))
  1064.    (:stack :aliasptr)
  1065.    (:stack-trap #xAA5C :d0 792 prli))
  1066.  
  1067. ; 
  1068. ; This call returns a pointer to a packed RLI that represents the "Catalogs" icon, or
  1069. ; the root of all directories.  It is used in the CollabPack.
  1070. ; 
  1071.  
  1072.  
  1073. (deftrap _ocegetdirectoryrootpackedrli nil
  1074.    (:stack (:pointer :packedrli))
  1075.    (:stack-trap #xAA5C :d0 838))
  1076.  
  1077. ; *** LocalRecordID ***
  1078.  
  1079. (defrecord LocalRecordID 
  1080.    (cid :CREATIONID)
  1081.    (recordName (:POINTER :RSTRING))
  1082.    (recordType (:POINTER :RSTRING))
  1083.    )
  1084.  
  1085. (def-mactype :LOCALRECORDIDPTR (find-mactype :POINTER))
  1086.  
  1087. ;  Create a LocalRecordID from a name, type, and CreationID 
  1088.  
  1089.  
  1090. (deftrap _ocenewlocalrecordid ((recordname (:pointer :rstring)) (recordtype (:pointer :rstring)) (cid :creationid) (lrid (:pointer :localrecordid)))
  1091.    nil
  1092.    (:stack-trap #xAA5C :d0 798 recordname recordtype cid lrid))
  1093.  
  1094. ; 
  1095. ; Copy LocalRecordID lRID1 to LocalRecordID lRID2.  lRID2 must already contain
  1096. ; pointers to RString structures large enough to hold copies of the corresponding
  1097. ; fields from lRID1.  A memFull error will be returned if that is not the case.
  1098. ; So if you allocate a brand new empty destination, you must at least set up
  1099. ; its length field.
  1100. ; 
  1101.  
  1102.  
  1103. (deftrap _ocecopylocalrecordid ((lrid1 :localrecordid) (lrid2 (:pointer :localrecordid)))
  1104.    (:stack :signed-integer)
  1105.    (:stack-trap #xAA5C :d0 770 lrid1 lrid2))
  1106.  
  1107. ; 
  1108. ; Check the equality of two local RIDs.
  1109. ; 
  1110.  
  1111.  
  1112. (deftrap _oceequallocalrecordid ((lrid1 :localrecordid) (lrid2 :localrecordid))
  1113.    (:stack :boolean)
  1114.    (:stack-trap #xAA5C :d0 783 lrid1 lrid2))
  1115.  
  1116. ; *** ShortRecordID ***
  1117.  
  1118. (defrecord ShortRecordID 
  1119.    (rli (:POINTER :PACKEDRLI))
  1120.    (cid :CREATIONID)
  1121.    )
  1122.  
  1123. (def-mactype :SHORTRECORDIDPTR (find-mactype :POINTER))
  1124.  
  1125. ;  Create a ShortRecordID from an RLI struct and a CreationID 
  1126.  
  1127.  
  1128. (deftrap _ocenewshortrecordid ((therli (:pointer :packedrli)) (cid :creationid) (srid (:pointer :shortrecordid)))
  1129.    nil
  1130.    (:stack-trap #xAA5C :d0 801 therli cid srid))
  1131.  
  1132. ; 
  1133. ; Copy ShortRecordID sRID1 to ShortRecordID sRID2.  sRID2 must already contain
  1134. ; pointers to structures large enough to hold copies of the corresponding
  1135. ; fields from sRID1.  A memFull error will be returned if that is not the case.
  1136. ; So if you allocate a brand new empty destination, you must at least set up
  1137. ; its length fields.
  1138. ; 
  1139.  
  1140.  
  1141. (deftrap _ocecopyshortrecordid ((srid1 :shortrecordid) (srid2 (:pointer :shortrecordid)))
  1142.    (:stack :signed-integer)
  1143.    (:stack-trap #xAA5C :d0 778 srid1 srid2))
  1144.  
  1145. ; 
  1146. ; Check the equality of two INTEGER RIDs.
  1147. ; 
  1148.  
  1149.  
  1150. (deftrap _oceequalshortrecordid ((srid1 :shortrecordid) (srid2 :shortrecordid))
  1151.    (:stack :boolean)
  1152.    (:stack-trap #xAA5C :d0 791 srid1 srid2))
  1153.  
  1154. ; *** RecordID ***
  1155.  
  1156. (defrecord RecordID 
  1157.    (rli (:POINTER :PACKEDRLI))  ;  pointer to a packed rli structure 
  1158.    (local :LOCALRECORDID)
  1159.    )
  1160.  
  1161. (def-mactype :RECORDIDPTR (find-mactype :POINTER))
  1162.  
  1163. ;     Create a RecordID from a packed RLI struct and a LocalRecordID.
  1164. ; This doesn't allocate any new space; the RecordID points to the same
  1165. ; packed RLI struct and the same name and type RStrings. 
  1166.  
  1167.  
  1168. (deftrap _ocenewrecordid ((therli (:pointer :packedrli)) (lrid :localrecordid) (rid (:pointer :recordid)))
  1169.    nil
  1170.    (:stack-trap #xAA5C :d0 800 therli lrid rid))
  1171.  
  1172. ; 
  1173. ; Copy RecordID RID1 to RecordID RID2.  RID2 must already contain
  1174. ; pointers to structures large enough to hold copies of the corresponding
  1175. ; fields from lRID1.  A memFull error will be returned if that is not the case.
  1176. ; So if you allocate a brand new empty destination, you must at least set up
  1177. ; its length fields.
  1178. ; 
  1179.  
  1180.  
  1181. (deftrap _ocecopyrecordid ((rid1 :recordid) (rid2 :recordid))
  1182.    (:stack :signed-integer)
  1183.    (:stack-trap #xAA5C :d0 777 rid1 rid2))
  1184.  
  1185. ;     Check the equality of two RIDs. 
  1186.  
  1187.  
  1188. (deftrap _oceequalrecordid ((rid1 :recordid) (rid2 :recordid))
  1189.    (:stack :boolean)
  1190.    (:stack-trap #xAA5C :d0 788 rid1 rid2))
  1191.  
  1192. ; *** PackedRecordID ***
  1193.  
  1194. ; 
  1195. ; struct PackedRecordID is a maximum-sized structure.  Allocate one of
  1196. ; these and it will hold any valid packed RecordID.
  1197. ; 
  1198.  
  1199. (defconstant $kPackedRecordIDMaxBytes 1824)
  1200.  
  1201. (defrecord PackedRecordIDHeader 
  1202.    (dataLength :SIGNED-INTEGER) ;  length excludes the space for the length field 
  1203.    )
  1204.  
  1205. (defrecord PackedRecordID 
  1206.    (dataLength :SIGNED-INTEGER)
  1207.  
  1208.    (data (:ARRAY :UNSIGNED-BYTE 1824))      ;  { (:ARRAY :UNSIGNED-BYTE (- #$KPACKEDRECORDIDMAXBYTES 1 -1)) }
  1209.    )
  1210.  
  1211. ; 
  1212. ; struct ProtoPackedRecordID is a minimum-sized structure.  Use this
  1213. ; for a variable-length packed RecordID.
  1214. ; 
  1215.  
  1216. (defrecord ProtoPackedRecordID 
  1217.    (dataLength :SIGNED-INTEGER)
  1218.  
  1219. ;  Followed by data 
  1220.    )
  1221.  
  1222. (def-mactype :PACKEDRECORDIDPTR (find-mactype :POINTER))
  1223. (def-mactype :PROTOPACKEDRECORDIDPTR (find-mactype :POINTER))
  1224.  
  1225. ; 
  1226. ; Copy PackedRecordID pRID1 to PackedRecordID pRID2.  pRID2 must already contain
  1227. ; pointers to structures large enough to hold copies of the corresponding
  1228. ; fields from pRID1.  A memFull error will be returned if that is not the case.
  1229. ; pRID2Length is the number of bytes that can be put into pRID2, not counting the
  1230. ; packed RecordID header.
  1231. ; 
  1232.  
  1233.  
  1234. (deftrap _ocecopypackedrecordid ((prid1 (:pointer :packedrecordid)) (prid2 (:pointer :packedrecordid)) (prid2length :signed-integer))
  1235.    (:stack :signed-integer)
  1236.    (:stack-trap #xAA5C :d0 774 prid1 prid2 prid2length))
  1237.  
  1238. ; 
  1239. ; Create a RecordID from a PackedRecordID.
  1240. ; NOTE THAT THE UNPACKED STRUCT CONTAINS POINTERS INTO THE PACKED STRUCT - DON'T DELETE
  1241. ; OR REUSE THE PACKED STRUCT UNTIL YOU ARE FINISHED WITH THE UNPACKED STRUCT AS WELL
  1242. ; 
  1243.  
  1244.  
  1245. (deftrap _oceunpackrecordid ((prid (:pointer :packedrecordid)) (rid (:pointer :recordid)))
  1246.    nil
  1247.    (:stack-trap #xAA5C :d0 818 prid rid))
  1248.  
  1249. ; 
  1250. ; Create a PackedRecordID from a RecordID.  pRID must be large enough to contain
  1251. ; the packed RecordID.  A memFull error will be returned if that is not the case.
  1252. ; packedRecordIDLength is the number of bytes that can be put into pRID, not
  1253. ; counting the header.
  1254. ; 
  1255.  
  1256.  
  1257. (deftrap _ocepackrecordid ((rid :recordid) (prid (:pointer :packedrecordid)) (packedrecordidlength :signed-integer))
  1258.    (:stack :signed-integer)
  1259.    (:stack-trap #xAA5C :d0 806 rid prid packedrecordidlength))
  1260.  
  1261. ; 
  1262. ; Compute the number of bytes of memory needed to hold a RecordID when packed. This
  1263. ; length includes the length of the length field of PackedRecordID, so it
  1264. ; is safe to do a NewPtr (OCEPackedRecordIDSize(...)).
  1265. ; 
  1266.  
  1267.  
  1268. (deftrap _ocepackedrecordidsize ((rid :recordid))
  1269.    (:stack :signed-integer)
  1270.    (:stack-trap #xAA5C :d0 811 rid))
  1271.  
  1272. ; 
  1273. ; Check the equality of two packed RIDs.
  1274. ; 
  1275.  
  1276.  
  1277. (deftrap _oceequalpackedrecordid ((prid1 (:pointer :packedrecordid)) (prid2 (:pointer :packedrecordid)))
  1278.    (:stack :boolean)
  1279.    (:stack-trap #xAA5C :d0 786 prid1 prid2))
  1280.  
  1281. ;  OCEValidPackedRecordID checks the validity of a packed record ID. 
  1282.  
  1283.  
  1284. (deftrap _ocevalidpackedrecordid ((prid (:pointer :packedrecordid)))
  1285.    (:stack :boolean)
  1286.    (:stack-trap #xAA5C :d0 821 prid))
  1287.  
  1288. ; *** DSSpec ***
  1289.  
  1290. (defrecord DSSpec 
  1291.    (entitySpecifier (:POINTER :RECORDID))
  1292.    (extensionType :OSTYPE)
  1293.    (extensionSize :SIGNED-INTEGER)
  1294.    (extensionValue :POINTER)
  1295.    )
  1296.  
  1297. (def-mactype :DSSPECPTR (find-mactype :POINTER))
  1298.  
  1299. ; 
  1300. ; struct PackedDSSpec is NOT a maximum-sized structure.  Allocate one of
  1301. ; these and it will hold any valid packed RecordID, but not necessarily any additional
  1302. ; data.
  1303. ; 
  1304.  
  1305. (defconstant $kPackedDSSpecMaxBytes 1832)
  1306.  
  1307. (defrecord PackedDSSpecHeader 
  1308.    (dataLength :SIGNED-INTEGER) ;  length excludes the space for the length field 
  1309.    )
  1310.  
  1311. (defrecord PackedDSSpec 
  1312.    (dataLength :SIGNED-INTEGER)
  1313.  
  1314.    (data (:ARRAY :UNSIGNED-BYTE 1832))        ;  { (:ARRAY :UNSIGNED-BYTE (- #$KPACKEDDSSPECMAXBYTES 1 -1)) }
  1315.    )
  1316.  
  1317. ; 
  1318. ; struct ProtoPackedDSSpec is a minimum-sized structure.  Use this
  1319. ; for a variable-length packed DSSpec.
  1320. ; 
  1321.  
  1322. (defrecord ProtoPackedDSSpec 
  1323.    (dataLength :SIGNED-INTEGER)
  1324.  
  1325. ;  Followed by data 
  1326.    )
  1327.  
  1328. (def-mactype :PACKEDDSSPECPTR (find-mactype :POINTER))
  1329. (def-mactype :PROTOPACKEDDSSPECPTR (find-mactype :POINTER))
  1330.  
  1331. ; 
  1332. ; Copy PackedDSSpec pdss1 to PackedDSSpec pdss2.  pdss2 must already contain
  1333. ; pointers to structures large enough to hold copies of the corresponding
  1334. ; fields from pdss1.  A memFull error will be returned if that is not the case.
  1335. ; pdss2Length is the number of bytes that can be put into pdss2, not counting the
  1336. ; packed DSSpec header.
  1337. ; 
  1338.  
  1339.  
  1340. (deftrap _ocecopypackeddsspec ((pdss1 (:pointer :packeddsspec)) (pdss2 (:pointer :packeddsspec)) (pdss2length :signed-integer))
  1341.    (:stack :signed-integer)
  1342.    (:stack-trap #xAA5C :d0 771 pdss1 pdss2 pdss2length))
  1343.  
  1344. ; 
  1345. ; Create a DSSpec from a PackedDSSpec.
  1346. ; NOTE THAT THE UNPACKED STRUCT CONTAINS POINTERS INTO THE PACKED STRUCT - DON'T DELETE
  1347. ; OR REUSE THE PACKED STRUCT UNTIL YOU ARE FINISHED WITH THE UNPACKED STRUCT AS WELL.
  1348. ; A pointer to the extension is returned in dss->extensionValue, and the length of that
  1349. ; extension is returned in dss->extensionSize.  If there is no extension, dss->extensionValue will
  1350. ; be set to nil.  This routine will unpack the RecordID (any: if) into rid, unpack the rest
  1351. ; into dss, and set dss->entitySpecifier to rid.
  1352. ; 
  1353.  
  1354.  
  1355. (deftrap _oceunpackdsspec ((pdss (:pointer :packeddsspec)) (dss (:pointer :dsspec)) (rid (:pointer :recordid)))
  1356.    nil
  1357.    (:stack-trap #xAA5C :d0 815 pdss dss rid))
  1358.  
  1359. ; 
  1360. ; Create a PackedDSSpec from a DSSpec.  pdss must be large enough to
  1361. ; contain the packed RecordID and any extension.  A memFull error will be returned if that
  1362. ; is not the case.  pdssLength is the number of bytes that can be put into pdss,
  1363. ; not counting the header.
  1364. ; 
  1365.  
  1366.  
  1367. (deftrap _ocepackdsspec ((dss :dsspec) (pdss (:pointer :packeddsspec)) (pdsslength :signed-integer))
  1368.    (:stack :signed-integer)
  1369.    (:stack-trap #xAA5C :d0 802 dss pdss pdsslength))
  1370.  
  1371. ; 
  1372. ; Compute the number of bytes of memory needed to hold a DSSpec when packed. This
  1373. ; length includes the length of the length field of PackedDSSpec, so it
  1374. ; is safe to do a NewPtr (OCEPackedDSSpecSize(...)).
  1375. ; 
  1376.  
  1377.  
  1378. (deftrap _ocepackeddsspecsize ((dss :dsspec))
  1379.    (:stack :signed-integer)
  1380.    (:stack-trap #xAA5C :d0 807 dss))
  1381.  
  1382. ;     Check the equality of two DSSpecs.  This compares all fields, even the
  1383. ; extension (unless extensionSize == 0).  The extensions are compared in a case-insensitive and
  1384. ; diacrit-insensitive manner. 
  1385.  
  1386.  
  1387. (deftrap _oceequaldsspec ((pdss1 :dsspec) (pdss2 :dsspec))
  1388.    (:stack :boolean)
  1389.    (:stack-trap #xAA5C :d0 782 pdss1 pdss2))
  1390.  
  1391. ;     Check the equality of two PackedDSSpecs.  This compares all fields, even the
  1392. ; extension (unless extensionSize == 0).  The extensions are compared in a case-insensitive and
  1393. ; diacrit-insensitive manner. 
  1394.  
  1395.  
  1396. (deftrap _oceequalpackeddsspec ((pdss1 (:pointer :packeddsspec)) (pdss2 (:pointer :packeddsspec)))
  1397.    (:stack :boolean)
  1398.    (:stack-trap #xAA5C :d0 784 pdss1 pdss2))
  1399.  
  1400. ; 
  1401. ; Check the validity of a PackedDSSpec.  If extensionType is
  1402. ; 'entn', pdss must contain a valid entitySpecifier.  For all other extensionTypes, a nil
  1403. ; entitySpecifier is valid, but if non-nil, it will be checked for validity.  No check
  1404. ; is made on the extension.
  1405. ; 
  1406.  
  1407.  
  1408. (deftrap _ocevalidpackeddsspec ((pdss (:pointer :packeddsspec)))
  1409.    (:stack :boolean)
  1410.    (:stack-trap #xAA5C :d0 819 pdss))
  1411.  
  1412. ; 
  1413. ; Return info about a DSSpec.  This routine does not check validity.  If the
  1414. ; DSSpec has no extension, we determine whether it represents the root of all
  1415. ; directories, a single directory, a DNode, or a Record.  Else it is invalid.
  1416. ; If the DSSpec has an extension, we simply return the extension type.
  1417. ; 
  1418.  
  1419.  
  1420. (deftrap _ocegetdsspecinfo ((spec :dsspec))
  1421.    (:stack :ostype)
  1422.    (:stack-trap #xAA5C :d0 793 spec))
  1423.  
  1424. ;  OCEGetExtensionType returns the extensionType imbedded in the PackedDSSpec. 
  1425.  
  1426.  
  1427. (deftrap _ocegetextensiontype ((pdss (:pointer :packeddsspec)))
  1428.    (:stack :ostype)
  1429.    (:stack-trap #xAA5C :d0 796 pdss))
  1430.  
  1431. ; 
  1432. ; OCEStreamPackedDSSpec streams (flattens) a directory object a little at a time by
  1433. ; calling the DSSpecStreamer routine that you provide.
  1434. ; 
  1435.  
  1436. (def-mactype :DSSPECSTREAMER (find-mactype :POINTER))
  1437. ;  FUNCTION DSSpecStreamer(VAR buffer: void; count: LONGINT; eof: BOOLEAN;
  1438. ;         userData: LONGINT): OSErr;
  1439.  
  1440.  
  1441. (deftrap _ocestreampackeddsspec ((dss :dsspec) (stream :pointer) (userdata :signed-long) (actualcount (:pointer :signed-long)))
  1442.    (:stack :signed-integer)
  1443.    (:stack-trap #xAA5C :d0 829 dss stream userdata actualcount))
  1444.  
  1445. ; *** AttributeType ***
  1446.  
  1447. ; 
  1448. ; For the record, an AttributeType is an RString with a smaller maximum size.
  1449. ; I don't justtypedef it to an RString, because I want the definition of the AttributeType
  1450. ; struct to contain the max length, because I need to include it in the Attribute struct
  1451. ; below.  But it should be possible to typecast any AttributeType to an RString and use
  1452. ; all the RString utilities on it.
  1453. ; 
  1454.  
  1455. (defrecord AttributeType 
  1456.    (charSet :SIGNED-INTEGER)
  1457.    (dataLength :SIGNED-INTEGER)
  1458.  
  1459.    (body (:ARRAY :UNSIGNED-BYTE 32))       ;  { (:ARRAY :UNSIGNED-BYTE (- #$KATTRIBUTETYPEMAXBYTES 1 -1)) }
  1460. ;  always fixed at the max size 
  1461.    )
  1462.  
  1463. (def-mactype :ATTRIBUTETYPEPTR (find-mactype :POINTER))
  1464.  
  1465. ; *** AttributeValue ***
  1466.  
  1467. (def-mactype :ATTRIBUTETAG (find-mactype :DESCTYPE));  same class as is used in AppleEvents 
  1468.  
  1469. (defrecord AttributeValue 
  1470.    (tag :DESCTYPE)
  1471.    (dataLength :SIGNED-LONG)
  1472.    (bytes :POINTER)
  1473.    )
  1474.  
  1475. (def-mactype :ATTRIBUTEVALUEPTR (find-mactype :POINTER))
  1476.  
  1477. ; *** Attribute ***
  1478.  
  1479. (defrecord Attribute 
  1480.    (AttributeType :ATTRIBUTETYPE)
  1481.    (cid :CREATIONID)
  1482.    (value :ATTRIBUTEVALUE)
  1483.    )
  1484.  
  1485. (def-mactype :ATTRIBUTEPTR (find-mactype :POINTER))
  1486.  
  1487.  
  1488. (deftrap _ocegetindrecordtype ((stringindex :signed-integer))
  1489.    (:stack (:pointer :rstring))
  1490.    (:stack-trap #xAA5C :d0 795 stringindex))
  1491.  
  1492.  
  1493. (deftrap _ocegetindattributetype ((stringindex :signed-integer))
  1494.    (:stack (:pointer :attributetype))
  1495.    (:stack-trap #xAA5C :d0 794 stringindex))
  1496.  
  1497. (defconstant _oceTBDispatch #XAA5E)
  1498.  
  1499. ; $ENDC                         ;  UsingOCE 
  1500.  
  1501. ; $IFC NOT UsingIncludes
  1502.  
  1503. ; $ENDC
  1504.  
  1505. (export '(_OCETBDISPATCH $KPACKEDDSSPECMAXBYTES $KPACKEDRECORDIDMAXBYTES
  1506.           $KMINPACKEDRLISIZE $KRLIMAXBYTES $KPATHNAMEMAXBYTESMINUSSIZEOFINTEGER
  1507.           $KMINPACKEDRSTRINGLENGTH $ATTRANSSFSHUTDOWN $ATTRANSSFSTART
  1508.           $ATTRANSAUTHSHUTDOWN $ATTRANSAUTHSTART $ATTRANSDIRSHUTDOWN
  1509.           $ATTRANSDIRSTART $ATTRANSIPMSHUTDOWN $ATTRANSIPMSTART
  1510.           $GESTALTOCESFSERVERAVAILABLE $GESTALTOCETBAVAILABLE
  1511.           $GESTALTOCETBPRESENT $GESTALTSFSERVER $GESTALTOCETB
  1512.           $GESTALTOCETOOLBOXATTR $GESTALTOCETOOLBOXVERSION $KFOREIGNNODE
  1513.           $KCANCONTAINRECORDS $KFOREIGNNODEBIT $KCANCONTAINRECORDSBIT
  1514.           $TYPEBINARY $TYPEPACKEDDSSPEC $TYPERSTRING $KOCENOTENTNDSSPEC
  1515.           $KOCEENTNDSSPEC $KOCERECORDDSSPEC $KOCEDNODEDSSPEC
  1516.           $KOCEDIRECTORYDSSPEC $KOCEDIRSROOTDSSPEC $KOCEINVALIDDSSPEC
  1517.           $KDIRDSAMKIND $KDIRPERSONALDIRECTORYKIND $KDIRADAPKIND $KDIRALLKINDS
  1518.           $KOCEGENERICINSENSITIVE $KOCEGENERICSENSITIVE $KOCEATTRTYPE
  1519.           $KOCENETWORKSPEC $KOCERECORDTYPE $KOCERECORDORDNODENAME $KOCEDIRNAME
  1520.           $KROOTDNODENUMBER $KNULLDNODENUMBER $KRSTRINGMAXCHARS
  1521.           $KRSTRINGMAXBYTES $KATTRVALUEMAXBYTES $KATTRIBUTETYPEMAXBYTES
  1522.           $KDIRECTORYNAMEMAXBYTES $KPATHNAMEMAXBYTES $KNETWORKSPECMAXBYTES
  1523.           $KRSTRING64SIZE $KRSTRING32SIZE $KGATEWAYTYPEATTRTYPEBODY
  1524.           $KDELETEREQUESTEDATTRTYPEBODY $KACTIVEATTRTYPEBODY
  1525.           $KLOCATIONNAMESATTRTYPEBODY $KVERSIONATTRTYPEBODY
  1526.           $KUNCONFIGUREDATTRTYPEBODY $KJOINEDATTRTYPEBODY
  1527.           $KMAILERSENDOPTIONSATTRTYPEBODY $KMAILERAOMSTATEATTRTYPEBODY
  1528.           $KLASTLOGINATTRTYPEBODY $KPREFERREDPDATTRTYPEBODY
  1529.           $KINHERITSYSADMINATTRTYPEBODY $KFAKEATTRTYPEBODY
  1530.           $KASSOMAILSERVICEATTRTYPEBODY $KSLOTATTRTYPEBODY
  1531.           $KPARENTDSAMATTRTYPEBODY $KPARENTMSAMATTRTYPEBODY $KALIASATTRTYPEBODY
  1532.           $KDISCRIMINATORATTRTYPEBODY $KCANADDRESSTOATTRTYPEBODY
  1533.           $KDSAMFILEALIASATTRTYPEBODY $KDIRTYPEATTRTYPEBODY
  1534.           $KPRIVATEDATAATTRTYPEBODY $KREALNAMEATTRTYPEBODY
  1535.           $KCOMMENTATTRTYPEBODY $KDIRNATIVENAMEATTRTYPEBODY
  1536.           $KDIRUSERKEYATTRTYPEBODY $KDIRUSERRIDATTRTYPEBODY
  1537.           $KLOCALKEYATTRTYPEBODY $KLOCALNAMEATTRTYPEBODY $KSFLAGSATTRTYPEBODY
  1538.           $KDIRECTORIESATTRTYPEBODY $KDIRECTORYATTRTYPEBODY
  1539.           $KASSODIRECTORYATTRTYPEBODY $KSTDSLOTINFOATTRTYPEBODY
  1540.           $KMAILSERVICEATTRTYPEBODY $KGATEWAYFILEIDATTRTYPEBODY
  1541.           $KSLOTIDATTRTYPEBODY $KMAILSETUPATTRTYPEBODY $KTBSETUPATTRTYPEBODY
  1542.           $KSHADOWSERVERATTRTYPEBODY $KSHADOWSOFATTRTYPEBODY
  1543.           $KUPDATETIMERATTRTYPEBODY $KTIMESVRTYPEATTRTYPEBODY
  1544.           $KLOCATIONATTRTYPEBODY $KNETWORKSPECATTRTYPEBODY
  1545.           $KPARENTCIDATTRTYPEBODY $KSERVERSOFATTRTYPEBODY
  1546.           $KMASTERNETSPECATTRTYPEBODY $KMASTERPFATTRTYPEBODY
  1547.           $KPREFMSGQATTRTYPEBODY $KMSGQSATTRTYPEBODY $KCERTIFICATEATTRTYPEBODY
  1548.           $KDESCRIPTORATTRTYPEBODY $KWRITELISTATTRTYPEBODY
  1549.           $KREADLISTATTRTYPEBODY $KOWNERSATTRTYPEBODY $KFOREIGNATTRTYPEBODY
  1550.           $KCONNECTATTRTYPEBODY $KFWDRLOCALATTRTYPEBODY $KCORESATTRTYPEBODY
  1551.           $KHOMENETATTRTYPEBODY $KDIALUPSLOTATTRTYPEBODY $KQMAPPINGATTRTYPEBODY
  1552.           $KNBPNAMEATTRTYPEBODY $KTELEPHONEATTRTYPEBODY $KAUTHKEYATTRTYPEBODY
  1553.           $KPICTUREATTRTYPEBODY $KADDRESSATTRTYPEBODY $KPREFMAILATTRTYPEBODY
  1554.           $KMAILSLOTSATTRTYPEBODY $KADMINSATTRTYPEBODY $KMEMBERATTRTYPEBODY
  1555.           $KAFPSERVICERECTYPEBODY $KOTHERSERVICERECTYPEBODY
  1556.           $KCOMBINEDRECTYPEBODY $KMAILSERVICERECTYPEBODY
  1557.           $KBUSINESSCARDRECTYPEBODY $KATTRIBUTEVALUERECTYPEBODY
  1558.           $KDSAMRECTYPEBODY $KMSAMRECTYPEBODY $KSETUPRECTYPEBODY
  1559.           $KDNODERECTYPEBODY $KDIRECTORYRECTYPEBODY $KSERVERSETUPRECTYPEBODY
  1560.           $KADAPDNODEREPRECTYPEBODY $KADAPDNODERECTYPEBODY
  1561.           $KADAPSERVERRECTYPEBODY $KNETWORKSPECRECTYPEBODY
  1562.           $KMNMFORWARDERRECTYPEBODY $KMNMRECTYPEBODY $KGROUPRECTYPEBODY
  1563.           $KUSERRECTYPEBODY $KNUMOCEATTRTYPES $KLASTOCEATTRTYPENUM
  1564.           $KFIRSTOCEATTRTYPENUM $KGATEWAYTYPEATTRTYPENUM
  1565.           $KDELETEREQUESTEDATTRTYPENUM $KACTIVEATTRTYPENUM
  1566.           $KLOCATIONNAMESATTRTYPENUM $KVERSIONATTRTYPENUM
  1567.           $KUNCONFIGUREDATTRTYPENUM $KJOINEDATTRTYPENUM
  1568.           $KMAILERSENDOPTIONSATTRTYPENUM $KMAILERAOMSTATEATTRTYPENUM
  1569.           $KLASTLOGINATTRTYPENUM $KPREFERREDPDATTRTYPENUM
  1570.           $KINHERITSYSADMINATTRTYPENUM $KFAKEATTRTYPENUM
  1571.           $KASSOMAILSERVICEATTRTYPENUM $KSLOTATTRTYPENUM
  1572.           $KPARENTDSAMATTRTYPENUM $KPARENTMSAMATTRTYPENUM $KALIASATTRTYPENUM
  1573.           $KDISCRIMINATORATTRTYPENUM $KCANADDRESSTOATTRTYPENUM
  1574.           $KDSAMFILEALIASATTRTYPENUM $KDIRTYPEATTRTYPENUM
  1575.           $KPRIVATEDATAATTRTYPENUM $KREALNAMEATTRTYPENUM $KCOMMENTATTRTYPENUM
  1576.           $KDIRNATIVENAMEATTRTYPENUM $KDIRUSERKEYATTRTYPENUM
  1577.           $KDIRUSERRIDATTRTYPENUM $KLOCALKEYATTRTYPENUM $KLOCALNAMEATTRTYPENUM
  1578.           $KSFLAGSATTRTYPENUM $KDIRECTORIESATTRTYPENUM $KDIRECTORYATTRTYPENUM
  1579.           $KASSODIRECTORYATTRTYPENUM $KSTDSLOTINFOATTRTYPENUM
  1580.           $KMAILSERVICEATTRTYPENUM $KGATEWAYFILEIDATTRTYPENUM
  1581.           $KSLOTIDATTRTYPENUM $KMAILSETUPATTRTYPENUM $KTBSETUPATTRTYPENUM
  1582.           $KSHADOWSERVERATTRTYPENUM $KSHADOWSOFATTRTYPENUM
  1583.           $KUPDATETIMERATTRTYPENUM $KTIMESVRTYPEATTRTYPENUM
  1584.           $KLOCATIONATTRTYPENUM $KNETWORKSPECATTRTYPENUM $KPARENTCIDATTRTYPENUM
  1585.           $KSERVERSOFATTRTYPENUM $KMASTERNETSPECATTRTYPENUM
  1586.           $KMASTERPFATTRTYPENUM $KPREFMSGQATTRTYPENUM $KMSGQSATTRTYPENUM
  1587.           $KCERTIFICATEATTRTYPENUM $KDESCRIPTORATTRTYPENUM
  1588.           $KWRITELISTATTRTYPENUM $KREADLISTATTRTYPENUM $KOWNERSATTRTYPENUM
  1589.           $KFOREIGNATTRTYPENUM $KCONNECTATTRTYPENUM $KFWDRLOCALATTRTYPENUM
  1590.           $KCORESATTRTYPENUM $KHOMENETATTRTYPENUM $KDIALUPSLOTATTRTYPENUM
  1591.           $KQMAPPINGATTRTYPENUM $KNBPNAMEATTRTYPENUM $KTELEPHONEATTRTYPENUM
  1592.           $KAUTHKEYATTRTYPENUM $KPICTUREATTRTYPENUM $KADDRESSATTRTYPENUM
  1593.           $KPREFMAILATTRTYPENUM $KMAILSLOTSATTRTYPENUM $KADMINSATTRTYPENUM
  1594.           $KMEMBERATTRTYPENUM $KNUMOCERECTYPES $KLASTOCERECTYPENUM
  1595.           $KFIRSTOCERECTYPENUM $KAFPSERVICERECTYPENUM $KOTHERSERVICERECTYPENUM
  1596.           $KCOMBINEDRECTYPENUM $KMAILSERVICERECTYPENUM $KBUSINESSCARDRECTYPENUM
  1597.           $KATTRIBUTEVALUERECTYPENUM $KDSAMRECTYPENUM $KMSAMRECTYPENUM
  1598.           $KSETUPRECTYPENUM $KDNODERECTYPENUM $KDIRECTORYRECTYPENUM
  1599.           $KSERVERSETUPRECTYPENUM $KADAPDNODEREPRECTYPENUM
  1600.           $KADAPDNODERECTYPENUM $KADAPSERVERRECTYPENUM $KNETWORKSPECRECTYPENUM
  1601.           $KMNMFORWARDERRECTYPENUM $KMNMRECTYPENUM $KGROUPRECTYPENUM
  1602.           $KUSERRECTYPENUM $KOCEGETROOTPACKEDRLI $KOCEGETACCESSCONTROLDSSPEC
  1603.           $KOCENULLCID $KOCESTREAMPACKEDDSSPEC $KOCEPATHFINDERCID
  1604.           $KOCERTOPSTRING $KOCEPTORSTRING $KOCECTORSTRING $KOCEVALIDRSTRING
  1605.           $KOCEVALIDRLI $KOCEVALIDPACKEDRLI $KOCEVALIDPACKEDRECORDID
  1606.           $KOCEVALIDPACKEDPATHNAME $KOCEVALIDPACKEDDSSPEC $KOCEUNPACKRECORDID
  1607.           $KOCEUNPACKRLI $KOCEUNPACKPATHNAME $KOCEUNPACKDSSPEC
  1608.           $KOCESETCREATIONIDTONULL $KOCERELRSTRING $KOCEDNODENAMECOUNT
  1609.           $KOCEPACKEDRECORDIDSIZE $KOCEPACKEDRLISIZE $KOCEPACKEDRLIPARTSSIZE
  1610.           $KOCEPACKEDPATHNAMESIZE $KOCEPACKEDDSSPECSIZE $KOCEPACKRECORDID
  1611.           $KOCEPACKRLIPARTS $KOCEPACKRLI $KOCEPACKPATHNAME $KOCEPACKDSSPEC
  1612.           $KOCENEWSHORTRECORDID $KOCENEWRECORDID $KOCENEWRLI
  1613.           $KOCENEWLOCALRECORDID $KOCEISNULLPACKEDPATHNAME $KOCEGETXTNTYPE
  1614.           $KOCEGETINDRECORDTYPE $KOCEGETINDATTRIBUTETYPE $KOCEGETDSSPECINFO
  1615.           $KOCEEXTRACTALIAS $KOCEEQUALSHORTRECORDID $KOCEEQUALRSTRING
  1616.           $KOCEEQUALRLI $KOCEEQUALRECORDID $KOCEEQUALPACKEDRLI
  1617.           $KOCEEQUALPACKEDRECORDID $KOCEEQUALPACKEDPATHNAME
  1618.           $KOCEEQUALPACKEDDSSPEC $KOCEEQUALLOCALRECORDID $KOCEEQUALDSSPEC
  1619.           $KOCEEQUALDIRDISCRIMINATOR $KOCEEQUALCREATIONID $KOCEDUPLICATERLI
  1620.           $KOCECOPYSHORTRECORDID $KOCECOPYRECORDID $KOCECOPYRSTRING
  1621.           $KOCECOPYRLI $KOCECOPYPACKEDRECORDID $KOCECOPYPACKEDRLI
  1622.           $KOCECOPYPACKEDPATHNAME $KOCECOPYPACKEDDSSPEC $KOCECOPYLOCALRECORDID
  1623.           $KOCECOPYDIRDISCRIMINATOR $KOCECOPYCREATIONID))
  1624. (provide-interface 'OCE)